home *** CD-ROM | disk | FTP | other *** search
/ Digitalfoto 118 / Digitalfoto 118.iso / pc / programas / 00 / splash.swf / scripts / __Packages / zigo / tweenManager.as
Encoding:
Text File  |  2008-10-31  |  22.9 KB  |  782 lines
  1. class zigo.tweenManager
  2. {
  3.    var playing;
  4.    var autoStop;
  5.    var broadcastEvents;
  6.    var autoOverwrite;
  7.    var ints;
  8.    var lockedTweens;
  9.    var tweenList;
  10.    var updateTime;
  11.    var tweenHolder;
  12.    var updateIntId;
  13.    var now;
  14.    var _th_depth = 6789;
  15.    function tweenManager()
  16.    {
  17.       this.playing = false;
  18.       this.autoStop = false;
  19.       this.broadcastEvents = false;
  20.       this.autoOverwrite = true;
  21.       this.ints = new Array();
  22.       this.lockedTweens = new Object();
  23.       this.tweenList = new Array();
  24.    }
  25.    function cleanUp()
  26.    {
  27.       if(!(this.tweenList instanceof Array && this.tweenList.length > 0))
  28.       {
  29.          return undefined;
  30.       }
  31.       for(var _loc2_ in this.tweenList)
  32.       {
  33.          if(this.tweenList[_loc2_].mc._x == undefined)
  34.          {
  35.             this.tweenList.splice(Number(_loc2_),1);
  36.          }
  37.       }
  38.       if(this.tweenList.length == 0)
  39.       {
  40.          this.tweenList = [];
  41.          this.deinit();
  42.       }
  43.       for(_loc2_ in this.ints)
  44.       {
  45.          if(this.ints[_loc2_] != undefined && this.ints[_loc2_].mc._x == undefined)
  46.          {
  47.             this.removeDelayedTween(Number(_loc2_));
  48.          }
  49.       }
  50.    }
  51.    function set updateInterval(time)
  52.    {
  53.       if(this.playing)
  54.       {
  55.          this.deinit();
  56.          this.updateTime = time;
  57.          this.init();
  58.       }
  59.       else
  60.       {
  61.          this.updateTime = time;
  62.       }
  63.    }
  64.    function get updateInterval()
  65.    {
  66.       return this.updateTime;
  67.    }
  68.    function set controllerDepth(v)
  69.    {
  70.       if(_global.isNaN(v) == true)
  71.       {
  72.          return;
  73.       }
  74.       if(this.tweenHolder._name != undefined)
  75.       {
  76.          this.tweenHolder.swapDepths(v);
  77.       }
  78.       else
  79.       {
  80.          this._th_depth = v;
  81.       }
  82.    }
  83.    function get controllerDepth()
  84.    {
  85.       return this._th_depth;
  86.    }
  87.    function init()
  88.    {
  89.       if(this.updateTime > 0)
  90.       {
  91.          clearInterval(this.updateIntId);
  92.          this.updateIntId = setInterval(this,"update",this.updateTime);
  93.       }
  94.       else
  95.       {
  96.          if(this.tweenHolder._name == undefined)
  97.          {
  98.             this.tweenHolder = _root.createEmptyMovieClip("_th_",this._th_depth);
  99.          }
  100.          var tm = this;
  101.          this.tweenHolder.onEnterFrame = function()
  102.          {
  103.             tm.update.call(tm);
  104.          };
  105.       }
  106.       this.playing = true;
  107.       this.now = getTimer();
  108.    }
  109.    function deinit()
  110.    {
  111.       this.playing = false;
  112.       clearInterval(this.updateIntId);
  113.       delete this.tweenHolder.onEnterFrame;
  114.    }
  115.    function update()
  116.    {
  117.       var _loc3_ = undefined;
  118.       var _loc11_ = undefined;
  119.       var _loc4_ = undefined;
  120.       var _loc14_ = false;
  121.       _loc11_ = this.tweenList.length;
  122.       if(this.broadcastEvents)
  123.       {
  124.          var _loc5_ = undefined;
  125.          var _loc8_ = undefined;
  126.          var _loc6_ = undefined;
  127.          var _loc10_ = undefined;
  128.          _loc5_ = {};
  129.          _loc8_ = {};
  130.          _loc6_ = {};
  131.          _loc10_ = {};
  132.       }
  133.       while(true)
  134.       {
  135.          _loc11_;
  136.          if(!_loc11_--)
  137.          {
  138.             break;
  139.          }
  140.          _loc3_ = this.tweenList[_loc11_];
  141.          if(_loc3_.mc._x == undefined)
  142.          {
  143.             _loc14_ = true;
  144.          }
  145.          else if(_loc3_.pt == -1)
  146.          {
  147.             if(_loc3_.ts + _loc3_.d > this.now)
  148.             {
  149.                if(_loc3_.ctm == undefined)
  150.                {
  151.                   if(_global.allowRounding)
  152.                   {
  153.                      _loc3_.mc[_loc3_.pp] = Math.round(_loc3_.ef(this.now - _loc3_.ts,_loc3_.ps,_loc3_.ch,_loc3_.d,_loc3_.e1,_loc3_.e2));
  154.                   }
  155.                   else
  156.                   {
  157.                      _loc3_.mc[_loc3_.pp] = _loc3_.ef(this.now - _loc3_.ts,_loc3_.ps,_loc3_.ch,_loc3_.d,_loc3_.e1,_loc3_.e2);
  158.                   }
  159.                }
  160.                else
  161.                {
  162.                   var _loc9_ = {};
  163.                   for(_loc4_ in _loc3_.ctm)
  164.                   {
  165.                      _loc9_[_loc4_] = _loc3_.ef(this.now - _loc3_.ts,_loc3_.stm[_loc4_],_loc3_.ctm[_loc4_],_loc3_.d,_loc3_.e1,_loc3_.e2);
  166.                   }
  167.                   _loc3_.c.setTransform(_loc9_);
  168.                }
  169.                if(this.broadcastEvents)
  170.                {
  171.                   if(_loc5_[targetPath(_loc3_.mc)] == undefined)
  172.                   {
  173.                      _loc5_[targetPath(_loc3_.mc)] = _loc3_.mc;
  174.                   }
  175.                   if(_loc6_[targetPath(_loc3_.mc)] == undefined)
  176.                   {
  177.                      _loc6_[targetPath(_loc3_.mc)] = [];
  178.                   }
  179.                   _loc6_[targetPath(_loc3_.mc)].push(_loc3_.ctm == undefined ? _loc3_.pp : "_ct_");
  180.                }
  181.                if(_loc3_.cb.updfunc != undefined)
  182.                {
  183.                   var _loc7_ = _loc3_.cb.updfunc;
  184.                   if(typeof _loc7_ == "string" && _loc3_.cb.updscope != undefined)
  185.                   {
  186.                      _loc7_ = _loc3_.cb.updscope[_loc7_];
  187.                   }
  188.                   _loc7_.apply(_loc3_.cb.updscope,_loc3_.cb.updargs);
  189.                }
  190.             }
  191.             else
  192.             {
  193.                if(_loc3_.ctm == undefined)
  194.                {
  195.                   _loc3_.mc[_loc3_.pp] = _loc3_.ps + _loc3_.ch;
  196.                }
  197.                else
  198.                {
  199.                   _loc9_ = {};
  200.                   for(_loc4_ in _loc3_.ctm)
  201.                   {
  202.                      _loc9_[_loc4_] = _loc3_.stm[_loc4_] + _loc3_.ctm[_loc4_];
  203.                   }
  204.                   _loc3_.c.setTransform(_loc9_);
  205.                }
  206.                if(this.broadcastEvents)
  207.                {
  208.                   if(_loc5_[targetPath(_loc3_.mc)] == undefined)
  209.                   {
  210.                      _loc5_[targetPath(_loc3_.mc)] = _loc3_.mc;
  211.                   }
  212.                   if(_loc8_[targetPath(_loc3_.mc)] == undefined)
  213.                   {
  214.                      _loc8_[targetPath(_loc3_.mc)] = _loc3_.mc;
  215.                   }
  216.                   if(_loc6_[targetPath(_loc3_.mc)] == undefined)
  217.                   {
  218.                      _loc6_[targetPath(_loc3_.mc)] = [];
  219.                   }
  220.                   _loc6_[targetPath(_loc3_.mc)].push(_loc3_.ctm == undefined ? _loc3_.pp : "_ct_");
  221.                   if(_loc10_[targetPath(_loc3_.mc)] == undefined)
  222.                   {
  223.                      _loc10_[targetPath(_loc3_.mc)] = [];
  224.                   }
  225.                   _loc10_[targetPath(_loc3_.mc)].push(_loc3_.ctm == undefined ? _loc3_.pp : "_ct_");
  226.                }
  227.                if(_loc3_.cb.updfunc != undefined)
  228.                {
  229.                   _loc7_ = _loc3_.cb.updfunc;
  230.                   if(typeof _loc7_ == "string" && _loc3_.cb.updscope != undefined)
  231.                   {
  232.                      _loc7_ = _loc3_.cb.updscope[_loc7_];
  233.                   }
  234.                   _loc7_.updfunc.apply(_loc3_.cb.updscope,_loc3_.cb.updargs);
  235.                }
  236.                if(endt == undefined)
  237.                {
  238.                   var endt = new Array();
  239.                }
  240.                endt.push(_loc11_);
  241.             }
  242.          }
  243.       }
  244.       if(_loc14_)
  245.       {
  246.          this.cleanUp();
  247.       }
  248.       for(_loc4_ in _loc5_)
  249.       {
  250.          _loc5_[_loc4_].broadcastMessage("onTweenUpdate",{target:_loc5_[_loc4_],props:_loc6_[_loc4_]});
  251.       }
  252.       if(endt != undefined)
  253.       {
  254.          this.endTweens(endt);
  255.       }
  256.       for(_loc4_ in _loc8_)
  257.       {
  258.          _loc8_[_loc4_].broadcastMessage("onTweenEnd",{target:_loc8_[_loc4_],props:_loc10_[_loc4_]});
  259.       }
  260.       this.now = getTimer();
  261.       if(this.updateTime > 0)
  262.       {
  263.          updateAfterEvent();
  264.       }
  265.    }
  266.    function endTweens(tid_arr)
  267.    {
  268.       var _loc2_ = undefined;
  269.       var _loc9_ = undefined;
  270.       var _loc3_ = undefined;
  271.       var _loc5_ = undefined;
  272.       var _loc8_ = undefined;
  273.       _loc2_ = [];
  274.       _loc9_ = tid_arr.length;
  275.       _loc3_ = 0;
  276.       while(_loc3_ < _loc9_)
  277.       {
  278.          _loc5_ = this.tweenList[tid_arr[_loc3_]].cb;
  279.          if(_loc5_ != undefined)
  280.          {
  281.             var _loc6_ = true;
  282.             for(_loc8_ in _loc2_)
  283.             {
  284.                if(_loc2_[_loc8_] == _loc5_)
  285.                {
  286.                   _loc6_ = false;
  287.                   break;
  288.                }
  289.             }
  290.             if(_loc6_)
  291.             {
  292.                _loc2_.push(_loc5_);
  293.             }
  294.          }
  295.          this.tweenList.splice(tid_arr[_loc3_],1);
  296.          _loc3_ = _loc3_ + 1;
  297.       }
  298.       _loc3_ = 0;
  299.       while(_loc3_ < _loc2_.length)
  300.       {
  301.          var _loc4_ = _loc2_[_loc3_].func;
  302.          if(typeof _loc4_ == "string" && _loc2_[_loc3_].scope != undefined)
  303.          {
  304.             _loc4_ = _loc2_[_loc3_].scope[_loc4_];
  305.          }
  306.          _loc4_.apply(_loc2_[_loc3_].scope,_loc2_[_loc3_].args);
  307.          _loc3_ = _loc3_ + 1;
  308.       }
  309.       if(this.tweenList.length == 0)
  310.       {
  311.          this.deinit();
  312.       }
  313.    }
  314.    function removeDelayedTween(index)
  315.    {
  316.       clearInterval(this.ints[index].intid);
  317.       this.ints[index] = undefined;
  318.       var _loc2_ = true;
  319.       for(var _loc3_ in this.ints)
  320.       {
  321.          if(this.ints[_loc3_] != undefined)
  322.          {
  323.             _loc2_ = false;
  324.             break;
  325.          }
  326.       }
  327.       if(_loc2_)
  328.       {
  329.          this.ints = [];
  330.       }
  331.    }
  332.    function addTween(mc, props, pEnd, sec, eqFunc, callback, extra1, extra2)
  333.    {
  334.       var _loc4_ = undefined;
  335.       var _loc13_ = undefined;
  336.       var _loc6_ = undefined;
  337.       var _loc3_ = undefined;
  338.       var _loc2_ = undefined;
  339.       if(!this.playing)
  340.       {
  341.          this.init();
  342.       }
  343.       var _loc12_ = [];
  344.       for(_loc4_ in props)
  345.       {
  346.          _loc13_ = props[_loc4_];
  347.          _loc6_ = true;
  348.          if(_loc13_.substr(0,4) != "_ct_")
  349.          {
  350.             var _loc17_ = typeof pEnd[_loc4_] != "string" ? pEnd[_loc4_] - mc[_loc13_] : Number(pEnd[_loc4_]);
  351.             if(this.autoOverwrite)
  352.             {
  353.                for(_loc3_ in this.tweenList)
  354.                {
  355.                   _loc2_ = this.tweenList[_loc3_];
  356.                   if(_loc2_.mc == mc && _loc2_.pp == _loc13_)
  357.                   {
  358.                      _loc2_.ps = mc[_loc13_];
  359.                      _loc2_.ch = _loc17_;
  360.                      _loc2_.ts = this.now;
  361.                      _loc2_.d = sec * 1000;
  362.                      _loc2_.ef = eqFunc;
  363.                      _loc2_.cb = callback;
  364.                      _loc2_.e1 = extra1;
  365.                      _loc2_.e2 = extra2;
  366.                      _loc2_.pt = -1;
  367.                      _loc6_ = false;
  368.                      _loc12_.push(_loc2_.pp);
  369.                      break;
  370.                   }
  371.                }
  372.             }
  373.             if(_loc6_)
  374.             {
  375.                this.tweenList.unshift({mc:mc,pp:_loc13_,ps:mc[_loc13_],ch:_loc17_,ts:this.now,d:sec * 1000,ef:eqFunc,cb:callback,e1:extra1,e2:extra2,pt:-1});
  376.             }
  377.          }
  378.          else
  379.          {
  380.             var _loc16_ = new Color(mc);
  381.             var _loc20_ = _loc16_.getTransform();
  382.             var _loc19_ = {};
  383.             for(_loc3_ in pEnd[_loc4_])
  384.             {
  385.                if(pEnd[_loc4_][_loc3_] != _loc20_[_loc3_] && pEnd[_loc4_][_loc3_] != undefined)
  386.                {
  387.                   _loc19_[_loc3_] = typeof pEnd[_loc4_][_loc3_] != "string" ? pEnd[_loc4_][_loc3_] - _loc20_[_loc3_] : _loc20_[_loc3_] + Number(pEnd[_loc4_][_loc3_]);
  388.                }
  389.             }
  390.             if(this.autoOverwrite)
  391.             {
  392.                for(_loc3_ in this.tweenList)
  393.                {
  394.                   _loc2_ = this.tweenList[_loc3_];
  395.                   if(_loc2_.mc == mc && _loc2_.ctm != undefined)
  396.                   {
  397.                      _loc2_.c = _loc16_;
  398.                      _loc2_.stm = _loc20_;
  399.                      _loc2_.ctm = _loc19_;
  400.                      _loc2_.ts = this.now;
  401.                      _loc2_.d = sec * 1000;
  402.                      _loc2_.ef = eqFunc;
  403.                      _loc2_.cb = callback;
  404.                      _loc2_.e1 = extra1;
  405.                      _loc2_.e2 = extra2;
  406.                      _loc2_.pt = -1;
  407.                      _loc6_ = false;
  408.                      _loc12_.push("_ct_");
  409.                      break;
  410.                   }
  411.                }
  412.             }
  413.             if(_loc6_)
  414.             {
  415.                this.tweenList.unshift({mc:mc,c:_loc16_,stm:_loc20_,ctm:_loc19_,ts:this.now,d:sec * 1000,ef:eqFunc,cb:callback,e1:extra1,e2:extra2,pt:-1});
  416.             }
  417.          }
  418.       }
  419.       if(this.broadcastEvents)
  420.       {
  421.          if(_loc12_.length > 0)
  422.          {
  423.             mc.broadcastMessage("onTweenInterrupt",{target:mc,props:_loc12_});
  424.          }
  425.          mc.broadcastMessage("onTweenStart",{target:mc,props:props});
  426.       }
  427.       if(callback.startfunc != undefined)
  428.       {
  429.          var _loc27_ = callback.startfunc;
  430.          if(typeof _loc27_ == "string" && callback.startscope != undefined)
  431.          {
  432.             _loc27_ = callback.startscope[_loc27_];
  433.          }
  434.          _loc27_.apply(callback.startscope,callback.startargs);
  435.       }
  436.       if(sec == 0)
  437.       {
  438.          this.update();
  439.       }
  440.    }
  441.    function addTweenWithDelay(delay, mc, props, pEnd, sec, eqFunc, callback, extra1, extra2)
  442.    {
  443.       var il;
  444.       var _loc3_ = undefined;
  445.       il = this.ints.length;
  446.       _loc3_ = setInterval(function(obj)
  447.       {
  448.          obj.removeDelayedTween(il);
  449.          if(mc._x != undefined)
  450.          {
  451.             obj.addTween(mc,props,pEnd,sec,eqFunc,callback,extra1,extra2);
  452.          }
  453.       }
  454.       ,delay * 1000,this);
  455.       this.ints[il] = {mc:mc,props:props,pend:pEnd,intid:_loc3_,st:getTimer(),delay:delay * 1000,args:arguments.slice(1),pt:-1};
  456.       if(!this.playing)
  457.       {
  458.          this.init();
  459.       }
  460.    }
  461.    function removeTween(mc, props)
  462.    {
  463.       var _loc8_ = undefined;
  464.       var _loc2_ = undefined;
  465.       var _loc5_ = undefined;
  466.       _loc8_ = false;
  467.       if(props == undefined && this.broadcastEvents != true)
  468.       {
  469.          _loc8_ = true;
  470.       }
  471.       _loc2_ = this.tweenList.length;
  472.       var _loc4_ = {};
  473.       while(true)
  474.       {
  475.          _loc2_;
  476.          if(!_loc2_--)
  477.          {
  478.             break;
  479.          }
  480.          if(this.tweenList[_loc2_].mc == mc)
  481.          {
  482.             if(_loc8_)
  483.             {
  484.                this.tweenList.splice(_loc2_,1);
  485.             }
  486.             else
  487.             {
  488.                for(_loc5_ in props)
  489.                {
  490.                   if(this.tweenList[_loc2_].pp == props[_loc5_])
  491.                   {
  492.                      this.tweenList.splice(_loc2_,1);
  493.                      if(_loc4_[targetPath(mc)] == undefined)
  494.                      {
  495.                         _loc4_[targetPath(mc)] = {t:mc,p:[]};
  496.                      }
  497.                      _loc4_[targetPath(mc)].p.push(props[_loc5_]);
  498.                   }
  499.                   else if(props[_loc5_] == "_ct_" && this.tweenList[_loc2_].ctm != undefined && this.tweenList[_loc2_].mc == mc)
  500.                   {
  501.                      this.tweenList.splice(_loc2_,1);
  502.                      if(_loc4_[targetPath(mc)] == undefined)
  503.                      {
  504.                         _loc4_[targetPath(mc)] = {t:mc,p:[]};
  505.                      }
  506.                      _loc4_[targetPath(mc)].p.push("_ct_");
  507.                   }
  508.                }
  509.             }
  510.          }
  511.       }
  512.       _loc2_ = this.ints.length;
  513.       while(true)
  514.       {
  515.          _loc2_;
  516.          if(!_loc2_--)
  517.          {
  518.             break;
  519.          }
  520.          if(this.ints[_loc2_].mc == mc)
  521.          {
  522.             if(_loc8_)
  523.             {
  524.                this.removeDelayedTween(Number(_loc2_));
  525.             }
  526.             else
  527.             {
  528.                for(_loc5_ in props)
  529.                {
  530.                   for(var _loc11_ in this.ints[_loc2_].props)
  531.                   {
  532.                      if(this.ints[_loc2_].props[_loc11_] == props[_loc5_])
  533.                      {
  534.                         this.ints[_loc2_].props.splice(_loc11_,1);
  535.                         this.ints[_loc2_].pend.splice(_loc11_,1);
  536.                         if(_loc4_[targetPath(mc)] == undefined)
  537.                         {
  538.                            _loc4_[targetPath(mc)] = {t:mc,p:[]};
  539.                         }
  540.                         _loc4_[targetPath(mc)].p.push(props[_loc5_]);
  541.                      }
  542.                   }
  543.                   if(this.ints[_loc2_].props.length == 0)
  544.                   {
  545.                      clearInterval(this.ints[_loc2_].intid);
  546.                   }
  547.                }
  548.             }
  549.          }
  550.       }
  551.       if(this.broadcastEvents)
  552.       {
  553.          for(_loc11_ in _loc4_)
  554.          {
  555.             if(_loc4_[_loc11_].p.length > 0)
  556.             {
  557.                _loc4_[_loc11_].t.broadcastMessage("onTweenInterrupt",{target:_loc4_[_loc11_].t,props:_loc4_[_loc11_].p});
  558.             }
  559.          }
  560.       }
  561.       if(this.tweenList.length == 0)
  562.       {
  563.          this.deinit();
  564.       }
  565.    }
  566.    function isTweening(mc, prop)
  567.    {
  568.       var _loc4_ = prop == undefined;
  569.       for(var _loc6_ in this.tweenList)
  570.       {
  571.          var _loc2_ = this.tweenList[_loc6_];
  572.          if(this.tweenList[_loc6_].mc == mc && this.tweenList[_loc6_].pt == -1 && (_loc4_ || prop == _loc2_.pp || prop == "_ct_" && _loc2_.ctm != undefined))
  573.          {
  574.             return true;
  575.          }
  576.       }
  577.       return false;
  578.    }
  579.    function getTweens(mc)
  580.    {
  581.       var _loc2_ = 0;
  582.       for(var _loc4_ in this.tweenList)
  583.       {
  584.          if(this.tweenList[_loc4_].mc == mc)
  585.          {
  586.             _loc2_ = _loc2_ + 1;
  587.          }
  588.       }
  589.       return _loc2_;
  590.    }
  591.    function lockTween(mc, bool)
  592.    {
  593.       this.lockedTweens[targetPath(mc)] = bool;
  594.    }
  595.    function isTweenLocked(mc)
  596.    {
  597.       if(this.lockedTweens[targetPath(mc)] == undefined)
  598.       {
  599.          return false;
  600.       }
  601.       return this.lockedTweens[targetPath(mc)];
  602.    }
  603.    function ffTween(mc, propsObj)
  604.    {
  605.       var _loc4_ = mc == undefined;
  606.       var _loc6_ = propsObj == undefined;
  607.       for(var _loc8_ in this.tweenList)
  608.       {
  609.          var _loc2_ = this.tweenList[_loc8_];
  610.          if((_loc2_.mc == mc || _loc4_) && (_loc6_ || propsObj[_loc2_.pp] == true))
  611.          {
  612.             if(_loc2_.pt != -1)
  613.             {
  614.                _loc2_.pt = -1;
  615.             }
  616.             _loc2_.ts = this.now - _loc2_.d;
  617.          }
  618.       }
  619.       for(_loc8_ in this.ints)
  620.       {
  621.          if(this.ints[_loc8_] != undefined)
  622.          {
  623.             if(this.ints[_loc8_].mc == mc || _loc4_)
  624.             {
  625.                if(this.ints[_loc8_].mc._x != undefined)
  626.                {
  627.                   var _loc3_ = this.ints[_loc8_].args;
  628.                   _loc3_[3] = 0;
  629.                   this.addTween.apply(this,_loc3_);
  630.                }
  631.                this.removeDelayedTween(Number(_loc8_));
  632.             }
  633.          }
  634.       }
  635.       this.update();
  636.    }
  637.    function rewTween(mc, propsObj)
  638.    {
  639.       var _loc3_ = mc == undefined;
  640.       var _loc5_ = propsObj == undefined;
  641.       for(var _loc7_ in this.tweenList)
  642.       {
  643.          var _loc2_ = this.tweenList[_loc7_];
  644.          if((_loc2_.mc == mc || _loc3_) && (_loc5_ || propsObj[_loc2_.pp] == true))
  645.          {
  646.             if(_loc2_.pt != -1)
  647.             {
  648.                _loc2_.pt = -1;
  649.             }
  650.             _loc2_.ts = this.now;
  651.          }
  652.       }
  653.       for(_loc7_ in this.ints)
  654.       {
  655.          if(this.ints[_loc7_] != undefined)
  656.          {
  657.             if(this.ints[_loc7_].mc == mc || _loc3_)
  658.             {
  659.                if(this.ints[_loc7_].mc._x != undefined)
  660.                {
  661.                   this.addTween.apply(this,this.ints[_loc7_].args);
  662.                }
  663.                this.removeDelayedTween(Number(_loc7_));
  664.             }
  665.          }
  666.       }
  667.       this.update();
  668.    }
  669.    function isTweenPaused(mc, prop)
  670.    {
  671.       if(mc == undefined)
  672.       {
  673.          return null;
  674.       }
  675.       var _loc5_ = prop == undefined;
  676.       for(var _loc6_ in this.tweenList)
  677.       {
  678.          var _loc2_ = this.tweenList[_loc6_];
  679.          if(this.tweenList[_loc6_].mc == mc && (_loc5_ || prop == _loc2_.pp || prop == "_ct_" && _loc2_.ctm != undefined))
  680.          {
  681.             return Boolean(this.tweenList[_loc6_].pt != -1);
  682.          }
  683.       }
  684.       for(_loc6_ in this.ints)
  685.       {
  686.          if(this.ints[_loc6_] != undefined && this.ints[_loc6_].mc == mc)
  687.          {
  688.             return Boolean(this.ints[_loc6_].pt != -1);
  689.          }
  690.       }
  691.       return false;
  692.    }
  693.    function pauseTween(mc, propsObj)
  694.    {
  695.       var _loc3_ = mc == undefined;
  696.       if(_loc3_ == false && this.isTweenPaused(mc) == true)
  697.       {
  698.          return undefined;
  699.       }
  700.       var _loc6_ = propsObj == undefined;
  701.       for(var _loc7_ in this.tweenList)
  702.       {
  703.          var _loc2_ = this.tweenList[_loc7_];
  704.          if(_loc2_.pt == -1 && (_loc2_.mc == mc || _loc3_) && (_loc6_ || propsObj[_loc2_.pp] == true || propsObj._ct_ != undefined && _loc2_.ctm != undefined))
  705.          {
  706.             _loc2_.pt = this.now;
  707.          }
  708.       }
  709.       for(_loc7_ in this.ints)
  710.       {
  711.          if(this.ints[_loc7_] != undefined)
  712.          {
  713.             if(this.ints[_loc7_].pt == -1 && (this.ints[_loc7_].mc == mc || _loc3_))
  714.             {
  715.                this.ints[_loc7_].pt = this.now;
  716.             }
  717.          }
  718.       }
  719.    }
  720.    function unpauseTween(mc, propsObj)
  721.    {
  722.       var _loc4_ = mc == undefined;
  723.       if(_loc4_ == false && this.isTweenPaused(mc) === false)
  724.       {
  725.          return undefined;
  726.       }
  727.       var _loc7_ = propsObj == undefined;
  728.       if(!this.playing)
  729.       {
  730.          this.init();
  731.       }
  732.       for(var _loc2_ in this.tweenList)
  733.       {
  734.          var _loc3_ = this.tweenList[_loc2_];
  735.          if(_loc3_.pt != -1 && (_loc3_.mc == mc || _loc4_) && (_loc7_ || propsObj[_loc3_.pp] == true) || propsObj._ct_ != undefined && _loc3_.ctm != undefined)
  736.          {
  737.             _loc3_.ts = this.now - (_loc3_.pt - _loc3_.ts);
  738.             _loc3_.pt = -1;
  739.          }
  740.       }
  741.       for(_loc2_ in this.ints)
  742.       {
  743.          if(this.ints[_loc2_] != undefined)
  744.          {
  745.             if(this.ints[_loc2_].pt != -1 && (this.ints[_loc2_].mc == mc || _loc4_))
  746.             {
  747.                this.ints[_loc2_].delay -= this.ints[_loc2_].pt - this.ints[_loc2_].st;
  748.                this.ints[_loc2_].st = this.now;
  749.                this.ints[_loc2_].intid = setInterval(function(obj, id)
  750.                {
  751.                   obj.addTween.apply(obj,obj.ints[id].args);
  752.                   clearInterval(obj.ints[id].intid);
  753.                   obj.ints[id] = undefined;
  754.                }
  755.                ,this.ints[_loc2_].delay,this,_loc2_);
  756.             }
  757.          }
  758.       }
  759.    }
  760.    function pauseAll()
  761.    {
  762.       this.pauseTween();
  763.    }
  764.    function unpauseAll()
  765.    {
  766.       this.unpauseTween();
  767.    }
  768.    function stopAll()
  769.    {
  770.       for(var _loc2_ in this.ints)
  771.       {
  772.          this.removeDelayedTween(Number(_loc2_));
  773.       }
  774.       this.tweenList = new Array();
  775.       this.deinit();
  776.    }
  777.    function toString()
  778.    {
  779.       return "[AS2 tweenManager 1.2.0]";
  780.    }
  781. }
  782.